const PALETTE_HEX: [&str; 48] = [
	"1b112c", "413047", "543e54", "75596f", "91718b", "b391aa", "ccb3c6", "e3cfe3", "fff7ff", "fffbb5", "faf38e", "f7d076", "fa9c69", "eb7363", "e84545", "c22e53", "943054", "612147", "3d173c", "3f233c", "66334b", "8c4b63", "c16a7d", "e5959f", "ffccd0", "dd8d9f", "c8658d", "b63f82", "9e2083", "731f7a", "47195d", "2a143d", "183042", "1e5451", "2a6957", "3b804d", "5aa653", "86cf74", "caf095", "e0f0bd", "3f275e", "3f317a","3c548f", "456aa1", "4a84b0", "56aec4", "92d7d9", "c3ebe3",
];

use palette::Srgb;

fn palette_as_rgb() -> Vec<Srgb> {
	let mut rgb_palette: Vec<Srgb> = vec![];
	for hex in PALETTE_HEX {
		let rgb = hex_to_rgb(hex).unwrap();
		rgb_palette.push(rgb);
	}
	rgb_palette
	}
	
fn hex_to_rgb(hex: &str) -> Result<Srgb, &'static str> {
	if hex.len() != 6 {
		return Err("Invalid hex color code");
	}
	
	let r = u8::from_str_radix(&hex[0..2], 16)
		.map_err(|_| "Invalid hex color code")?;
	let g = u8::from_str_radix(&hex[2..4], 16)
		.map_err(|_| "Invalid hex color code")?;
	let b = u8::from_str_radix(&hex[4..6], 16)
		.map_err(|_| "Invalid hex color code")?;
	
	Ok(Srgb::new(
		r as f32 / 255.0,
		g as f32 / 255.0,
		b as f32 / 255.0,
	))
}

fn main() -> Result<(), ImageError> {
	let img = Reader::open(IMAGE_PATH)?.decode()?;
	let pixels = img.as_rgba8().unwrap().enumerate_pixels();
	let mut output_buffer = ImageBuffer::new(img.width(), img.height());
	let palette_rgb = palette_as_rgb();
	
	for pixel in pixels {
		// is it witchcraft time yet?
	}
	output_buffer.save("img/output.png").unwrap();
	Ok(())
}

use palette::{Srgb, color_difference::EuclideanDistance};

fn find_closest(palette: &Vec<Srgb>, color: Srgb) -> Srgb {
	let mut dist_of_closest = std::f32::MAX;
	let mut closest = Srgb::new(0.0, 0.0, 0.0);
	
	for palette_color in palette {
		let d = color.distance_squared(*palette_color);
		if d < dist_of_closest {
			dist_of_closest = d;
			closest = *palette_color
		}
	}
	closest
}

fn main() -> Result<(), ImageError> {
// --snip--
	for pixel in pixels {
		let (x, y) = (pixel.0, pixel.1);
		let [r, g, b, a] = pixel.2.0;
		let pixel_rgb = Srgb::new(
			r as f32 / 255.0,
			g as f32 / 255.0,
			b as f32 / 255.0
		);
		// find the closest color in the palette to the pixel at (x, y)
		let closest = find_closest(&palette_rgb, pixel_rgb);
		// output the new color to the buffer
		let output_pixel = output_buffer.get_pixel_mut(x, y);
		
		*output_pixel = image::Rgba([
			(closest.red * 255.0) as u8,
			(closest.green * 255.0) as u8,
			(closest.blue * 255.0) as u8,
			a,
		]);
	// save as an image
	output_buffer.save("img/output.png").unwrap();
	Ok(())
}

use palette::{color_difference::EuclideanDistance, IntoColor, Srgb, Oklab};

fn palette_as_oklab() -> Vec<Oklab> {
    let mut oklab_palette: Vec<Oklab> = vec![];
    for hex in PALETTE_HEX {
        let rgb = hex_to_rgb(hex).unwrap();
        oklab_palette.push(rgb.into_color());
    }
    oklab_palette
}

fn find_closest(palette: &Vec<Oklab>, color: Oklab) -> Oklab {
	let mut dist_of_closest = std::f32::MAX;
	let mut closest = Oklab::new(0.0, 0.0, 0.0);
	
	for palette_color in palette {
		let d = color.distance_squared(*palette_color);
		if d < dist_of_closest {
			dist_of_closest = d;
			closest = *palette_color
		}
	}
	closest
}

fn main() -> Result<(), ImageError> {
	// --snip--
	let palette_rgb = palette_as_oklab();
	for pixel in pixels {
		let (x, y) = (pixel.0, pixel.1);
		let [r, g, b, a] = pixel.2 .0;
		
		let pixel_rgb = Srgb::new(
			r as f32 / 255.0,
			g as f32 / 255.0,
			b as f32 / 255.0
		);
		let pixel_oklab: Oklab = pixel_rgb.into_color();
		let closest_oklab = find_closest(&palette_oklab, pixel_oklab);
		let closest_rgb: Srgb = closest_oklab.into_color();
		
		let output_pixel = output_buffer.get_pixel_mut(x, y);
		*output_pixel = image::Rgba([
			(closest_rgb.red * 255.0) as u8,
			(closest_rgb.green * 255.0) as u8,
			(closest_rgb.blue * 255.0) as u8,
			a,
		]);
	}
	// --snip--
}

use image::{io::Reader, ImageBuffer, ImageError};
use palette::{color_difference::EuclideanDistance, IntoColor, Oklab, Srgb};
// read/write filepaths
const INPUT_PATH: &str = "img/input.png";
const OUTPUT_PATH: &str = "img/output.png";
// Bayer matrix definition
const THRESHOLD_MAP: [[usize; 2]; 2] = [[0, 2], [3, 1]];
const MAP_SIZE: usize = THRESHOLD_MAP.len();
// Dithering controls for color and transparency
const COLOR_DITHER: f32 = 0.04;
const ALPHA_DITHER: f32 = 0.12;
// Color palette of choice
const PALETTE_HEX: [&str; 8] = [
    "0d2b45", "203c56", "544e68", "8d697a", "d08159", "ffaa5e", "ffd4a3", "ffecd6",
];

fn palette_as_oklab() -> Vec<Oklab> {
    let mut oklab_palette: Vec<Oklab> = vec![];
    for hex in PALETTE_HEX {
        let rgb = hex_to_rgb(hex).unwrap();
        oklab_palette.push(rgb.into_color());
    }
    oklab_palette
}

fn hex_to_rgb(hex: &str) -> Result<Srgb, &'static str> {
    if hex.len() != 6 {
        return Err("Invalid hex color code");
    }
	
    let r = u8::from_str_radix(&hex[0..2], 16).map_err(|_| "Invalid hex color code")?;
    let g = u8::from_str_radix(&hex[2..4], 16).map_err(|_| "Invalid hex color code")?;
    let b = u8::from_str_radix(&hex[4..6], 16).map_err(|_| "Invalid hex color code")?;
	
    Ok(Srgb::new(
        r as f32 / 255.0,
        g as f32 / 255.0,
        b as f32 / 255.0,
    ))
}

fn find_closest(palette: &Vec<Oklab>, color: Oklab) -> Oklab {
    let mut dist_of_closest = std::f32::MAX;
    let mut closest = Oklab::new(0.0, 0.0, 0.0);
	
    for palette_color in palette {
        let d = color.distance_squared(*palette_color);
        if d < dist_of_closest {
            dist_of_closest = d;
            closest = *palette_color
        }
    }
    closest
}

fn main() -> Result<(), ImageError> {
    // import color palette
    let palette_oklab = palette_as_oklab();
    // import source image
    let img = Reader::open(INPUT_PATH)?.decode()?;
    let pixels = img.as_rgba8().unwrap().enumerate_pixels();
    // create a place to store output pixels
    let mut output_buffer = ImageBuffer::new(img.width(), img.height());
	
    for pixel in pixels {
        let (x, y) = (pixel.0, pixel.1);
        let [r, g, b, a] = pixel.2 .0;
        let alpha_f32 = (a as f32) / 255.0;
        // cast pixel to oklab
        let pixel_rgb = Srgb::new(r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0);
        let pixel_oklab: Oklab = pixel_rgb.into_color();
        // create a list of candidate color and alpha values
        let mut candidates_c: Vec<Oklab> = vec![];
        let mut candidates_a: Vec<f32> = vec![];
        let mut error_c = Oklab::new(0.0, 0.0, 0.0);
        let mut error_a = 0.0;
        for _ in 0..MAP_SIZE.pow(2) {
            // color
            let sample_c = pixel_oklab + error_c * COLOR_DITHER;
            let candidate_c = find_closest(&palette_oklab, sample_c);
            candidates_c.push(candidate_c);
            error_c += pixel_oklab - candidate_c;
			
            // alpha
            let sample_a = alpha_f32 + error_a * ALPHA_DITHER;
            let candidate_a = sample_a.round();
            candidates_a.push(candidate_a);
            error_a += alpha_f32 - candidate_a;
        }
		
        // sort candidates by brightness and alpha, respectively
        candidates_c
            .sort_by(|Oklab { l: l1, .. }, Oklab { l: l2, .. }| l1.partial_cmp(l2).unwrap());
        candidates_a.sort_by(|a1, a2| a1.partial_cmp(&a2).unwrap());

        // choose a candidate based on the pixel coordinates
        let index = THRESHOLD_MAP[x as usize % MAP_SIZE][y as usize % MAP_SIZE];
        let chosen_color: Srgb = candidates_c[index].into_color();
        let chosen_alpha = candidates_a[index];
		
        // write new pixel color to the output buffer
        let output_pixel = output_buffer.get_pixel_mut(x, y);
        *output_pixel = image::Rgba([
            (chosen_color.red * 255.0) as u8,
            (chosen_color.green * 255.0) as u8,
            (chosen_color.blue * 255.0) as u8,
            (chosen_alpha * 255.0) as u8,
        ]);
    }
	
    // save as a png
    output_buffer.save(OUTPUT_PATH).unwrap();
    Ok(())
}